home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 242 / Issue 242 - April 2008 - DPCS0408DVD.ISO / Software Money Savers / VirtualDub / Source / VirtualDub-1.7.7-src.7z / src / Priss / source / layer1.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2006-03-14  |  5.8 KB  |  213 lines
  1. //    Priss (NekoAmp 2.0) - MPEG-1/2 audio decoding library
  2. //    Copyright (C) 2003 Avery Lee
  3. //
  4. //    This program is free software; you can redistribute it and/or modify
  5. //    it under the terms of the GNU General Public License as published by
  6. //    the Free Software Foundation; either version 2 of the License, or
  7. //    (at your option) any later version.
  8. //
  9. //    This program is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. //    GNU General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU General Public License
  15. //    along with this program; if not, write to the Free Software
  16. //    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #include "engine.h"
  19. #include "bitreader.h"
  20.  
  21. // The format of an MPEG layer I frame:
  22. //
  23. // 1) bit allocations for separate subbands (4 bits per channel per subband)
  24. // 2) bit allocations for joint subbands (4 bits per subband)
  25. // 3) scale factors (6 bits per channel per subband that has bits allocated)
  26. // 4) repeated 12 times:
  27. //    a) samples for seperate subbands (n bits per channel per subband)
  28. //    b) samples for joint subbands (n bits per subband)
  29. //
  30. // There are up to two channels and always 32 subbands.  Channels in the joint
  31. // stereo range share the same samples but may have different scale factors.
  32.  
  33. bool VDMPEGAudioDecoder::DecodeLayerI() {
  34.     unsigned    bitalloc[32][2] = {0};        // bit allocations
  35.     float        scalefac[32][2];            // scale factors
  36.     unsigned    sb;                            // subband, channel
  37.     unsigned    bound = 32;                // subband limit for stereo encoding
  38.     bool        stereo = mMode != 3;
  39.  
  40.     if (mMode == 1)
  41.         bound = mModeExtension * 4 + 4;
  42.  
  43.     if (!stereo)
  44.         bound = 0;
  45.  
  46.     // The most critical case for layer I decoding is 32Kbps, 48KHz stereo.
  47.     // That gives a frame size of 32 bytes, or 28 bytes of sound payload.
  48.  
  49.     VDMPEGAudioBitReader bits(mFrameBuffer, mFrameDataSize);
  50.  
  51.     // read in bit allocations
  52.     //
  53.     // Worst case is 2 channels x 32 subbands x 4 bits = 32 bytes.  So,
  54.     // unfortunately, even this stage can die. :(
  55.  
  56.     if (!bits.chkavail(32*4 + bound*4))
  57.         throw (int)ERR_INCOMPLETEFRAME;
  58.  
  59.     unsigned nonzero_s=0, total_s=0;
  60.  
  61.     for(sb=0; sb<bound; ++sb) {
  62.         bitalloc[sb][0] = bits.get(4);
  63.         bitalloc[sb][1] = bits.get(4);
  64.  
  65.         if (bitalloc[sb][0]) {
  66.             ++bitalloc[sb][0];
  67.             ++nonzero_s;
  68.             total_s += bitalloc[sb][0];
  69.         }
  70.  
  71.         if (bitalloc[sb][1]) {
  72.             ++bitalloc[sb][1];
  73.             ++nonzero_s;
  74.             total_s += bitalloc[sb][1];
  75.         }
  76.     }
  77.  
  78.     unsigned nonzero_js = 0, total_js = 0;
  79.  
  80.     for(; sb<32; ++sb) {
  81.         bitalloc[sb][0] = bits.get(4);
  82.  
  83.         if (bitalloc[sb][0]) {
  84.             ++bitalloc[sb][0];
  85.             ++nonzero_js;
  86.             total_js += bitalloc[sb][0];
  87.             bitalloc[sb][1] = bitalloc[sb][0];
  88.         }
  89.     }
  90.  
  91.     // Bit check.
  92.     //
  93.     // We need 6 bits per non-zero bitalloc for scalefactors, and N*12 bits for
  94.     // samples.  For joint stereo bands, samples are shared but scalefactors are
  95.     // not.
  96.  
  97.     unsigned scf_and_samples_bits = 6*nonzero_js + 12*total_js;
  98.  
  99.     if (stereo)
  100.         scf_and_samples_bits += 6*(nonzero_s + nonzero_js) + 12*total_s;
  101.  
  102.     if (!bits.chkavail(scf_and_samples_bits))
  103.         throw (int)ERR_INCOMPLETEFRAME;
  104.  
  105. #ifdef _DEBUG
  106.     const unsigned expected_left = bits.avail() - scf_and_samples_bits;
  107. #endif
  108.  
  109.     // read in scale factors (convert bit allocation indices to bits on the way)
  110.  
  111.     static const float sL1Dequant[14]={
  112.         2.0f / 3.0f,
  113.         2.0f / 7.0f,
  114.         2.0f / 15.0f,
  115.         2.0f / 31.0f,
  116.         2.0f / 63.0f,
  117.         2.0f / 127.0f,
  118.         2.0f / 255.0f,
  119.         2.0f / 511.0f,
  120.         2.0f / 1023.0f,
  121.         2.0f / 2047.0f,
  122.         2.0f / 4095.0f,
  123.         2.0f / 8191.0f,
  124.         2.0f / 16383.0f,
  125.         2.0f / 32767.0f,
  126.     };
  127.  
  128.     if (stereo) {
  129.         for(sb=0; sb<32; ++sb) {
  130.             if (bitalloc[sb][0])
  131.                 scalefac[sb][0] = mL2Scalefactors[bits.get(6)] * sL1Dequant[bitalloc[sb][0] - 2];
  132.  
  133.             if (bitalloc[sb][1])
  134.                 scalefac[sb][1] = mL2Scalefactors[bits.get(6)] * sL1Dequant[bitalloc[sb][1] - 2];
  135.         }
  136.     } else {
  137.         for(sb=0; sb<32; ++sb) {
  138.             if (bitalloc[sb][0])
  139.                 scalefac[sb][0] = mL2Scalefactors[bits.get(6)] * sL1Dequant[bitalloc[sb][0] - 2];
  140.         }
  141.     }
  142.  
  143.     // dequantize subband samples and run through polyphase
  144.     // (12*32 = 384 samples/frame)
  145.     //
  146.     // The layer I dequantization algorithm, according to 11172-3:
  147.     // 1) Grab bits as two's complement value.
  148.     // 2) Toggle MSB.
  149.     // 3) Divide by 2^N so fraction is in [-.5, .5).
  150.     // 4) Compute y = (2^N / (2^N-1)) * (x + 2^(1-N)).
  151.     //
  152.     // Steps 1 and 2 essentially decode a biased value:
  153.     //    x = (getbits(N) - 2^(N-1)) / 2^N
  154.     //
  155.     // We can absorb the additional bias from step 4:
  156.     //    x' = (getbits(N) - 2^(N-1) + 2) / 2^N
  157.     //
  158.     // All ones as a sample is not valid.
  159.  
  160.     for(unsigned s=0; s<12; ++s) {
  161.         float sample[2][32];
  162.  
  163.         for(sb=0; sb<bound; ++sb) {
  164.             float x = 0.0f, y = 0.0f;
  165.  
  166.             if (unsigned b0 = bitalloc[sb][0])
  167.                 x = ((int)bits.get(b0) + 1 - (1<<(b0-1))) * scalefac[sb][0];
  168.  
  169.             if (unsigned b1 = bitalloc[sb][1])
  170.                 y = ((int)bits.get(b1) + 1 - (1<<(b1-1))) * scalefac[sb][1];
  171.  
  172.             sample[0][sb] = x;
  173.             sample[1][sb] = y;
  174.         }
  175.  
  176.         if (stereo) {
  177.             for(; sb<32; ++sb) {
  178.                 float x = 0.0f, y = 0.0f;
  179.  
  180.                 if (unsigned b0 = bitalloc[sb][0]) {
  181.                     float s = (float)((int)bits.get(b0) + 1 - (1<<(b0-1)));
  182.                     x = s * scalefac[sb][0];
  183.                     y = s * scalefac[sb][1];
  184.                 }
  185.  
  186.                 sample[0][sb] = x;
  187.                 sample[1][sb] = y;
  188.             }
  189.         } else {
  190.             for(; sb<32; ++sb) {
  191.                 float x = 0.0f;
  192.  
  193.                 if (unsigned b0 = bitalloc[sb][0])
  194.                     x = ((int)bits.get(b0) + 1 - (1<<(b0-1))) * scalefac[sb][0];
  195.  
  196.                 sample[0][sb] = sample[1][sb] = x;
  197.             }
  198.         }
  199.  
  200.         mpPolyphaseFilter->Generate(sample[0], stereo?sample[1]:NULL, mpSampleDst);
  201.  
  202.         mpSampleDst += stereo ? 64 : 32;
  203.     }
  204.  
  205.     mSamplesDecoded = stereo ? 768 : 384;
  206.  
  207. #ifdef _DEBUG
  208.     VDASSERT(bits.avail() == expected_left);
  209. #endif
  210.  
  211.     return true;
  212. }
  213.